# type_traits

Go to the documentation of this file.

    00001 // TR1 type_traits -*- C++ -*-
    00002
    00003 // Copyright (C) 2004, 2005 Free Software Foundation, Inc.
    00004 //
    00005 // This file is part of the GNU ISO C++ Library.  This library is free
    00006 // software; you can redistribute it and/or modify it under the
    00007 // terms of the GNU General Public License as published by the
    00008 // Free Software Foundation; either version 2, or (at your option)
    00009 // any later version.
    00010
    00011 // This library is distributed in the hope that it will be useful,
    00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00014 // GNU General Public License for more details.
    00015
    00016 // You should have received a copy of the GNU General Public License along
    00017 // with this library; see the file COPYING.  If not, write to the Free
    00018 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    00019 // USA.
    00020
    00021 // As a special exception, you may use this file as part of a free software
    00022 // library without restriction.  Specifically, if other files instantiate
    00023 // templates or use macros or inline functions from this file, or you compile
    00024 // this file and link it with other files to produce an executable, this
    00025 // file does not by itself cause the resulting executable to be covered by
    00026 // the GNU General Public License.  This exception does not however
    00027 // invalidate any other reasons why the executable file might be covered by
    00028 // the GNU General Public License.
    00029
    00030 /** @file
    00031  *  This is a TR1 C++ Library header.
    00032  */
    00033
    00034 #ifndef _TYPE_TRAITS
    00035 #define _TYPE_TRAITS 1
    00036
    00037 #include <bits/c++config.h>
    00038 #include <tr1/type_traits_fwd.h>
    00039
    00040 // namespace std::tr1
    00041 namespace std
    00042 {
    00043 namespace tr1
    00044 {
    00045   // For use in __conv_helper, is_abstract and elsewhere.
    00046   struct __sfinae_types
    00047   {
    00048     typedef char __one;
    00049     typedef struct { char __arr[2]; } __two;
    00050   };
    00051
    00052   template<typename _From, typename _To>
    00053     struct __conv_helper
    00054     : public __sfinae_types
    00055     {
    00056     private:
    00057       static __one __test(_To);
    00058       static __two __test(...);
    00059       static _From __makeFrom();
    00060
    00061     public:
    00062       static const bool __value = sizeof(__test(__makeFrom())) == 1;
    00063     };
    00064
    00065 #define _DEFINE_SPEC_BODY(_Value)                                    \
    00066     : public integral_constant<bool, _Value> { };
    00067
    00068 #define _DEFINE_SPEC_0_HELPER(_Spec, _Value)                         \
    00069   template<>                                                         \
    00070     struct _Spec                                                     \
    00071     _DEFINE_SPEC_BODY(_Value)
    00072
    00073 #define _DEFINE_SPEC_1_HELPER(_Spec, _Value)                         \
    00074   template<typename _Tp>                                             \
    00075     struct _Spec                                                     \
    00076     _DEFINE_SPEC_BODY(_Value)
    00077
    00078 #define _DEFINE_SPEC_2_HELPER(_Spec, _Value)                         \
    00079   template<typename _Tp, typename _Cp>                               \
    00080     struct _Spec                                                     \
    00081     _DEFINE_SPEC_BODY(_Value)
    00082
    00083 #define _DEFINE_SPEC(_Order, _Trait, _Type, _Value)                  \
    00084   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type>, _Value)              \
    00085   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const>, _Value)        \
    00086   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type volatile>, _Value)     \
    00087   _DEFINE_SPEC_##_Order##_HELPER(_Trait<_Type const volatile>, _Value)
    00088
    00089   /// @brief  helper classes [4.3].
    00090   template<typename _Tp, _Tp __v>
    00091     struct integral_constant
    00092     {
    00093       static const _Tp                      value = __v;
    00094       typedef _Tp                           value_type;
    00095       typedef integral_constant<_Tp, __v>   type;
    00096     };
    00097   typedef integral_constant<bool, true>     true_type;
    00098   typedef integral_constant<bool, false>    false_type;
    00099
    00100   /// @brief  primary type categories [4.5.1].
    00101   template<typename>
    00102     struct is_void
    00103     : public false_type { };
    00104   _DEFINE_SPEC(0, is_void, void, true)
    00105
    00106   template<typename>
    00107     struct is_integral
    00108     : public false_type { };
    00109   _DEFINE_SPEC(0, is_integral, bool, true)
    00110   _DEFINE_SPEC(0, is_integral, char, true)
    00111   _DEFINE_SPEC(0, is_integral, signed char, true)
    00112   _DEFINE_SPEC(0, is_integral, unsigned char, true)
    00113 #ifdef _GLIBCXX_USE_WCHAR_T
    00114   _DEFINE_SPEC(0, is_integral, wchar_t, true)
    00115 #endif
    00116   _DEFINE_SPEC(0, is_integral, short, true)
    00117   _DEFINE_SPEC(0, is_integral, unsigned short, true)
    00118   _DEFINE_SPEC(0, is_integral, int, true)
    00119   _DEFINE_SPEC(0, is_integral, unsigned int, true)
    00120   _DEFINE_SPEC(0, is_integral, long, true)
    00121   _DEFINE_SPEC(0, is_integral, unsigned long, true)
    00122   _DEFINE_SPEC(0, is_integral, long long, true)
    00123   _DEFINE_SPEC(0, is_integral, unsigned long long, true)
    00124
    00125   template<typename>
    00126     struct is_floating_point
    00127     : public false_type { };
    00128   _DEFINE_SPEC(0, is_floating_point, float, true)
    00129   _DEFINE_SPEC(0, is_floating_point, double, true)
    00130   _DEFINE_SPEC(0, is_floating_point, long double, true)
    00131
    00132   template<typename>
    00133     struct is_array
    00134     : public false_type { };
    00135
    00136   template<typename _Tp, std::size_t _Size>
    00137     struct is_array<_Tp[_Size]>
    00138     : public true_type { };
    00139
    00140   template<typename _Tp>
    00141     struct is_array<_Tp[]>
    00142     : public true_type { };
    00143
    00144   template<typename>
    00145     struct is_pointer
    00146     : public false_type { };
    00147   _DEFINE_SPEC(1, is_pointer, _Tp*, true)
    00148
    00149   template<typename>
    00150     struct is_reference
    00151     : public false_type { };
    00152
    00153   template<typename _Tp>
    00154     struct is_reference<_Tp&>
    00155     : public true_type { };
    00156
    00157   template<typename>
    00158     struct is_member_object_pointer
    00159     : public false_type { };
    00160   _DEFINE_SPEC(2, is_member_object_pointer, _Tp _Cp::*,
    00161            !is_function<_Tp>::value)
    00162
    00163   template<typename>
    00164     struct is_member_function_pointer
    00165     : public false_type { };
    00166   _DEFINE_SPEC(2, is_member_function_pointer, _Tp _Cp::*,
    00167            is_function<_Tp>::value)
    00168
    00169   template<typename _Tp>
    00170     struct is_enum
    00171     : public integral_constant<bool, !(is_fundamental<_Tp>::value
    00172                        || is_array<_Tp>::value
    00173                        || is_pointer<_Tp>::value
    00174                        || is_reference<_Tp>::value
    00175                        || is_member_pointer<_Tp>::value
    00176                        || is_function<_Tp>::value
    00177                        || __is_union_or_class<_Tp>::value)>
    00178     { };
    00179
    00180   template<typename>
    00181     struct is_union { };
    00182
    00183   template<typename>
    00184     struct is_class { };
    00185
    00186   template<typename _Tp, bool = (is_void<_Tp>::value
    00187                  || is_reference<_Tp>::value)>
    00188     struct __is_function_helper
    00189     {
    00190       static const bool __value = (__conv_helper<typename
    00191                    add_reference<_Tp>::type, typename
    00192                    add_pointer<_Tp>::type>::__value);
    00193     };
    00194
    00195   template<typename _Tp>
    00196     struct __is_function_helper<_Tp, true>
    00197     { static const bool __value = false; };
    00198
    00199   template<typename _Tp>
    00200     struct is_function
    00201     : public integral_constant<bool, __is_function_helper<_Tp>::__value>
    00202     { };
    00203
    00204   /// @brief  composite type traits [4.5.2].
    00205   template<typename _Tp>
    00206     struct is_arithmetic
    00207     : public integral_constant<bool, (is_integral<_Tp>::value
    00208                       || is_floating_point<_Tp>::value)>
    00209     { };
    00210
    00211   template<typename _Tp>
    00212     struct is_fundamental
    00213     : public integral_constant<bool, (is_arithmetic<_Tp>::value
    00214                       || is_void<_Tp>::value)>
    00215     { };
    00216
    00217   template<typename _Tp>
    00218     struct is_object
    00219     : public integral_constant<bool, !(is_function<_Tp>::value
    00220                        || is_reference<_Tp>::value
    00221                        || is_void<_Tp>::value)>
    00222     { };
    00223
    00224   template<typename _Tp>
    00225     struct is_scalar
    00226     : public integral_constant<bool, (is_arithmetic<_Tp>::value
    00227                       || is_enum<_Tp>::value
    00228                       || is_pointer<_Tp>::value
    00229                       || is_member_pointer<_Tp>::value)>
    00230     { };
    00231
    00232   template<typename _Tp>
    00233     struct is_compound
    00234     : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
    00235
    00236   template<typename _Tp>
    00237     struct is_member_pointer
    00238     : public integral_constant<bool,
    00239                    (is_member_object_pointer<_Tp>::value
    00240                 || is_member_function_pointer<_Tp>::value)>
    00241     { };
    00242
    00243   template<typename _Tp>
    00244     struct __is_union_or_class_helper
    00245     : public __sfinae_types
    00246     {
    00247     private:
    00248       template<typename _Up>
    00249         static __one __test(int _Up::*);
    00250       template<typename>
    00251         static __two __test(...);
    00252
    00253     public:
    00254       static const bool __value = sizeof(__test<_Tp>(0)) == 1;
    00255     };
    00256
    00257   // Extension.
    00258   template<typename _Tp>
    00259     struct __is_union_or_class
    00260     : public integral_constant<bool, __is_union_or_class_helper<_Tp>::__value>
    00261     { };
    00262
    00263   /// @brief  type properties [4.5.3].
    00264   template<typename>
    00265     struct is_const
    00266     : public false_type { };
    00267
    00268   template<typename _Tp>
    00269     struct is_const<_Tp const>
    00270     : public true_type { };
    00271
    00272   template<typename>
    00273     struct is_volatile
    00274     : public false_type { };
    00275
    00276   template<typename _Tp>
    00277     struct is_volatile<_Tp volatile>
    00278     : public true_type { };
    00279
    00280   template<typename _Tp>
    00281     struct is_pod
    00282     : public integral_constant<bool, (is_void<_Tp>::value
    00283                       || is_scalar<typename
    00284                       remove_all_extents<_Tp>::type>::value)>
    00285     { };
    00286
    00287   // N.B. Without compiler support we cannot tell union from class types,
    00288   // and is_empty and is_polymorphic don't work at all with the former.
    00289   template<typename _Tp, bool = !__is_union_or_class<_Tp>::value>
    00290     struct __is_empty_helper
    00291     {
    00292     private:
    00293       template<typename>
    00294         struct __first { };
    00295       template<typename _Up>
    00296         struct __second
    00297         : public _Up { };
    00298
    00299     public:
    00300       static const bool __value = sizeof(__first<_Tp>) == sizeof(__second<_Tp>);
    00301     };
    00302
    00303   template<typename _Tp>
    00304     struct __is_empty_helper<_Tp, true>
    00305     { static const bool __value = false; };
    00306
    00307   template<typename _Tp>
    00308     struct is_empty
    00309     : public integral_constant<bool, __is_empty_helper<_Tp>::__value>
    00310     { };
    00311
    00312   template<typename _Tp, bool = !__is_union_or_class<_Tp>::value>
    00313     struct __is_polymorphic_helper
    00314     {
    00315     private:
    00316       template<typename _Up>
    00317         struct __first
    00318         : public _Up { };
    00319       template<typename _Up>
    00320         struct __second
    00321         : public _Up
    00322     {
    00323       virtual void __dummy();
    00324       virtual ~__second();
    00325     };
    00326
    00327     public:
    00328       static const bool __value = sizeof(__first<_Tp>) == sizeof(__second<_Tp>);
    00329     };
    00330
    00331   template<typename _Tp>
    00332     struct __is_polymorphic_helper<_Tp, true>
    00333     { static const bool __value = false; };
    00334
    00335   template<typename _Tp>
    00336     struct is_polymorphic
    00337     : public integral_constant<bool, __is_polymorphic_helper<_Tp>::__value>
    00338     { };
    00339
    00340   // Exploit the resolution DR core/337.
    00341   template<typename _Tp, bool = !is_object<_Tp>::value>
    00342     struct __is_abstract_helper
    00343     : public __sfinae_types
    00344     {
    00345     private:
    00346       template<typename>
    00347         static __one __test(...);
    00348       template<typename _Up>
    00349         static __two __test(_Up(*)[1]);
    00350
    00351     public:
    00352       static const bool __value = sizeof(__test<_Tp>(0)) == 1;
    00353     };
    00354
    00355   template<typename _Tp>
    00356     struct __is_abstract_helper<_Tp, true>
    00357     { static const bool __value = false; };
    00358
    00359   template<typename _Tp>
    00360     struct is_abstract
    00361     : public integral_constant<bool, __is_abstract_helper<_Tp>::__value> { };
    00362
    00363   template<typename _Tp>
    00364     struct has_trivial_constructor
    00365     : public integral_constant<bool, is_pod<_Tp>::value> { };
    00366
    00367   template<typename _Tp>
    00368     struct has_trivial_copy
    00369     : public integral_constant<bool, is_pod<_Tp>::value> { };
    00370
    00371   template<typename _Tp>
    00372     struct has_trivial_assign
    00373     : public integral_constant<bool, is_pod<_Tp>::value> { };
    00374
    00375   template<typename _Tp>
    00376     struct has_trivial_destructor
    00377     : public integral_constant<bool, is_pod<_Tp>::value> { };
    00378
    00379   template<typename _Tp>
    00380     struct has_nothrow_constructor
    00381     : public integral_constant<bool, is_pod<_Tp>::value> { };
    00382
    00383   template<typename _Tp>
    00384     struct has_nothrow_copy
    00385     : public integral_constant<bool, is_pod<_Tp>::value> { };
    00386
    00387   template<typename _Tp>
    00388     struct has_nothrow_assign
    00389     : public integral_constant<bool, is_pod<_Tp>::value> { };
    00390
    00391   template<typename>
    00392     struct has_virtual_destructor
    00393     : public false_type { };
    00394
    00395   template<typename>
    00396     struct is_signed
    00397     : public false_type { };
    00398   _DEFINE_SPEC(0, is_signed, signed char, true)
    00399   _DEFINE_SPEC(0, is_signed, short, true)
    00400   _DEFINE_SPEC(0, is_signed, int, true)
    00401   _DEFINE_SPEC(0, is_signed, long, true)
    00402   _DEFINE_SPEC(0, is_signed, long long, true)
    00403
    00404   template<typename>
    00405     struct is_unsigned
    00406     : public false_type { };
    00407   _DEFINE_SPEC(0, is_unsigned, unsigned char, true)
    00408   _DEFINE_SPEC(0, is_unsigned, unsigned short, true)
    00409   _DEFINE_SPEC(0, is_unsigned, unsigned int, true)
    00410   _DEFINE_SPEC(0, is_unsigned, unsigned long, true)
    00411   _DEFINE_SPEC(0, is_unsigned, unsigned long long, true)
    00412
    00413   template<typename _Tp>
    00414     struct alignment_of
    00415     : public integral_constant<std::size_t, __alignof__(_Tp)> { };
    00416
    00417   template<typename>
    00418     struct rank
    00419     : public integral_constant<std::size_t, 0> { };
    00420
    00421   template<typename _Tp, std::size_t _Size>
    00422     struct rank<_Tp[_Size]>
    00423     : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
    00424
    00425   template<typename _Tp>
    00426     struct rank<_Tp[]>
    00427     : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
    00428
    00429   template<typename, unsigned>
    00430     struct extent
    00431     : public integral_constant<std::size_t, 0> { };
    00432
    00433   template<typename _Tp, unsigned _Uint, std::size_t _Size>
    00434     struct extent<_Tp[_Size], _Uint>
    00435     : public integral_constant<std::size_t,
    00436                    _Uint == 0 ? _Size : extent<_Tp,
    00437                                _Uint - 1>::value>
    00438     { };
    00439
    00440   template<typename _Tp, unsigned _Uint>
    00441     struct extent<_Tp[], _Uint>
    00442     : public integral_constant<std::size_t,
    00443                    _Uint == 0 ? 0 : extent<_Tp,
    00444                                _Uint - 1>::value>
    00445     { };
    00446
    00447   /// @brief  relationships between types [4.6].
    00448   template<typename, typename>
    00449     struct is_same
    00450     : public false_type { };
    00451
    00452   template<typename _Tp>
    00453     struct is_same<_Tp, _Tp>
    00454     : public true_type { };
    00455
    00456   // See Daveed Vandevoorde explanation in http://tinyurl.com/502f.
    00457   // Also see Rani Sharoni in http://tinyurl.com/6jvyq.
    00458   template<typename _Base, typename _Derived,
    00459        bool = (!__is_union_or_class<_Base>::value
    00460            || !__is_union_or_class<_Derived>::value
    00461            || is_same<_Base, _Derived>::value)>
    00462     struct __is_base_of_helper
    00463     : public __sfinae_types
    00464     {
    00465     private:
    00466       typedef typename remove_cv<_Base>::type     _NoCv_Base;
    00467       typedef typename remove_cv<_Derived>::type  _NoCv_Derived;
    00468
    00469       template<typename _Up>
    00470         static __one __test(_NoCv_Derived&, _Up);
    00471       static __two __test(_NoCv_Base&, int);
    00472
    00473       struct _Conv
    00474       {
    00475     operator _NoCv_Derived&();
    00476     operator _NoCv_Base&() const;
    00477       };
    00478
    00479     public:
    00480       static const bool __value = sizeof(__test(_Conv(), 0)) == 1;
    00481     };
    00482
    00483   template<typename _Base, typename _Derived>
    00484     struct __is_base_of_helper<_Base, _Derived, true>
    00485     { static const bool __value = is_same<_Base, _Derived>::value; };
    00486
    00487   template<typename _Base, typename _Derived>
    00488     struct is_base_of
    00489     : public integral_constant<bool,
    00490                    __is_base_of_helper<_Base, _Derived>::__value>
    00491     { };
    00492
    00493   template<typename _Tp>
    00494     struct __is_int_or_cref
    00495     {
    00496       typedef typename remove_reference<_Tp>::type __rr_Tp;
    00497       static const bool __value = (is_integral<_Tp>::value
    00498                    || (is_integral<__rr_Tp>::value
    00499                        && is_const<__rr_Tp>::value
    00500                        && !is_volatile<__rr_Tp>::value));
    00501     };
    00502
    00503   template<typename _From, typename _To,
    00504        bool = (is_function<_To>::value || is_array<_To>::value
    00505            // This special case is here only to avoid warnings.
    00506            || (is_floating_point<typename
    00507                remove_reference<_From>::type>::value
    00508                && __is_int_or_cref<_To>::__value))>
    00509     struct __is_convertible_helper
    00510     {
    00511       // "An imaginary lvalue of type From...".
    00512       static const bool __value = (__conv_helper<typename
    00513                    add_reference<_From>::type, _To>::__value);
    00514     };
    00515
    00516   template<typename _From, typename _To>
    00517     struct __is_convertible_helper<_From, _To, true>
    00518     { static const bool __value = __is_int_or_cref<_To>::__value; };
    00519
    00520   template<typename _From, typename _To>
    00521     struct is_convertible
    00522     : public integral_constant<bool,
    00523                    __is_convertible_helper<_From, _To>::__value>
    00524     { };
    00525
    00526   /// @brief  const-volatile modifications [4.7.1].
    00527   template<typename _Tp>
    00528     struct remove_const
    00529     { typedef _Tp     type; };
    00530
    00531   template<typename _Tp>
    00532     struct remove_const<_Tp const>
    00533     { typedef _Tp     type; };
    00534
    00535   template<typename _Tp>
    00536     struct remove_volatile
    00537     { typedef _Tp     type; };
    00538
    00539   template<typename _Tp>
    00540     struct remove_volatile<_Tp volatile>
    00541     { typedef _Tp     type; };
    00542
    00543   template<typename _Tp>
    00544     struct remove_cv
    00545     {
    00546       typedef typename
    00547       remove_const<typename remove_volatile<_Tp>::type>::type     type;
    00548     };
    00549
    00550   template<typename _Tp>
    00551     struct add_const
    00552     { typedef _Tp const     type; };
    00553
    00554   template<typename _Tp>
    00555     struct add_volatile
    00556     { typedef _Tp volatile     type; };
    00557
    00558   template<typename _Tp>
    00559     struct add_cv
    00560     {
    00561       typedef typename
    00562       add_const<typename add_volatile<_Tp>::type>::type     type;
    00563     };
    00564
    00565   /// @brief  reference modifications [4.7.2].
    00566   template<typename _Tp>
    00567     struct remove_reference
    00568     { typedef _Tp     type; };
    00569
    00570   template<typename _Tp>
    00571     struct remove_reference<_Tp&>
    00572     { typedef _Tp     type; };
    00573
    00574   template<typename _Tp>
    00575     struct add_reference
    00576     { typedef _Tp&    type; };
    00577
    00578   template<typename _Tp>
    00579     struct add_reference<_Tp&>
    00580     { typedef _Tp&    type; };
    00581
    00582   /// @brief  array modififications [4.7.3].
    00583   template<typename _Tp>
    00584     struct remove_extent
    00585     { typedef _Tp     type; };
    00586
    00587   template<typename _Tp, std::size_t _Size>
    00588     struct remove_extent<_Tp[_Size]>
    00589     { typedef _Tp     type; };
    00590
    00591   template<typename _Tp>
    00592     struct remove_extent<_Tp[]>
    00593     { typedef _Tp     type; };
    00594
    00595   template<typename _Tp>
    00596     struct remove_all_extents
    00597     { typedef _Tp     type; };
    00598
    00599   template<typename _Tp, std::size_t _Size>
    00600     struct remove_all_extents<_Tp[_Size]>
    00601     { typedef typename remove_all_extents<_Tp>::type     type; };
    00602
    00603   template<typename _Tp>
    00604     struct remove_all_extents<_Tp[]>
    00605     { typedef typename remove_all_extents<_Tp>::type     type; };
    00606
    00607   /// @brief  pointer modifications [4.7.4].
    00608 #undef _DEFINE_SPEC_BODY
    00609 #define _DEFINE_SPEC_BODY(_Value)      \
    00610     { typedef _Tp     type; };
    00611
    00612   template<typename _Tp>
    00613     struct remove_pointer
    00614     { typedef _Tp     type; };
    00615   _DEFINE_SPEC(1, remove_pointer, _Tp*, false)
    00616
    00617   template<typename _Tp>
    00618     struct add_pointer
    00619     { typedef typename remove_reference<_Tp>::type*     type; };
    00620
    00621   /// @brief  other transformations [4.8].
    00622
    00623   // Due to c++/19163 and c++/17743, for the time being we cannot use
    00624   // the correct, neat implementation :-(
    00625   //
    00626   // template<std::size_t _Len, std::size_t _Align>
    00627   //   struct aligned_storage
    00628   //   { typedef char type[_Len] __attribute__((__aligned__(_Align))); }
    00629   //
    00630   // Temporary workaround, useful for Align up to 32:
    00631   template<std::size_t, std::size_t>
    00632     struct aligned_storage { };
    00633
    00634   template<std::size_t _Len>
    00635     struct aligned_storage<_Len, 1>
    00636     {
    00637       union type
    00638       {
    00639     unsigned char __data[_Len];
    00640     char __align __attribute__((__aligned__(1)));
    00641       };
    00642     };
    00643
    00644   template<std::size_t _Len>
    00645     struct aligned_storage<_Len, 2>
    00646     {
    00647       union type
    00648       {
    00649     unsigned char __data[_Len];
    00650     char __align __attribute__((__aligned__(2)));
    00651       };
    00652     };
    00653
    00654   template<std::size_t _Len>
    00655     struct aligned_storage<_Len, 4>
    00656     {
    00657       union type
    00658       {
    00659     unsigned char __data[_Len];
    00660     char __align __attribute__((__aligned__(4)));
    00661       };
    00662     };
    00663
    00664   template<std::size_t _Len>
    00665     struct aligned_storage<_Len, 8>
    00666     {
    00667       union type
    00668       {
    00669     unsigned char __data[_Len];
    00670     char __align __attribute__((__aligned__(8)));
    00671       };
    00672     };
    00673
    00674   template<std::size_t _Len>
    00675     struct aligned_storage<_Len, 16>
    00676     {
    00677       union type
    00678       {
    00679     unsigned char __data[_Len];
    00680     char __align __attribute__((__aligned__(16)));
    00681       };
    00682     };
    00683
    00684   template<std::size_t _Len>
    00685     struct aligned_storage<_Len, 32>
    00686     {
    00687       union type
    00688       {
    00689     unsigned char __data[_Len];
    00690     char __align __attribute__((__aligned__(32)));
    00691       };
    00692     };
    00693
    00694 #undef _DEFINE_SPEC_0_HELPER
    00695 #undef _DEFINE_SPEC_1_HELPER
    00696 #undef _DEFINE_SPEC_2_HELPER
    00697 #undef _DEFINE_SPEC
    00698 #undef _DEFINE_SPEC_BODY
    00699
    00700 }
    00701 }
    00702
    00703 #endif