URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [libstdc++-v3/] [testsuite/] [util/] [testsuite_common_types.h] - Blame information for rev 516

Details | Compare with Previous | View Log


// -*- C++ -*-
// typelist for the C++ library testsuite. 
//
// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.
//
 
#ifndef _TESTSUITE_COMMON_TYPES_H
#define _TESTSUITE_COMMON_TYPES_H 1
 
#include <ext/typelist.h>
 
#include <ext/new_allocator.h>
#include <ext/malloc_allocator.h>
#include <ext/mt_allocator.h>
#include <ext/bitmap_allocator.h>
#include <ext/pool_allocator.h>
 
#include <algorithm>
 
#include <vector>
#include <list>
#include <deque>
#include <string>
 
#include <map>
#include <set>
#include <tr1/functional>
#include <tr1/unordered_map>
#include <tr1/unordered_set>
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <atomic>
#include <type_traits>
#endif
 
namespace __gnu_test
{
  using __gnu_cxx::typelist::node;
  using __gnu_cxx::typelist::transform;
  using __gnu_cxx::typelist::append;
 
  // All the allocators to test.
  template<typename Tp, bool Thread>
    struct allocator_policies
    {
      typedef Tp                                value_type;
      typedef __gnu_cxx::new_allocator<Tp>              a1;
      typedef __gnu_cxx::malloc_allocator<Tp>           a2;
      typedef __gnu_cxx::__common_pool_policy<__gnu_cxx::__pool, Thread> pool_policy;
      typedef __gnu_cxx::__mt_alloc<Tp, pool_policy>    a3;
      typedef __gnu_cxx::bitmap_allocator<Tp>           a4;
      typedef __gnu_cxx::__pool_alloc<Tp>               a5;
      typedef node<_GLIBCXX_TYPELIST_CHAIN5(a1, a2, a3, a4, a5)> type;
    };
 
  // Typelists for vector, string, list, deque.
  // XXX should just use template templates
  template<typename Tp, bool Thread>
    struct vectors
    {
      typedef Tp                                        value_type;
 
      template<typename Tl>
        struct vector_shell
        {
          typedef Tl                                    allocator_type;
          typedef std::vector<value_type, allocator_type>       type;
        };
 
      typedef allocator_policies<value_type, Thread>    allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, vector_shell>::type type;
    };
 
  template<typename Tp, bool Thread>
    struct lists
    {
      typedef Tp                                        value_type;
 
      template<typename Tl>
        struct list_shell
        {
          typedef Tl                                    allocator_type;
          typedef std::list<value_type, allocator_type> type;
        };
 
      typedef allocator_policies<value_type, Thread>    allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, list_shell>::type type;
    };
 
  template<typename Tp, bool Thread>
    struct deques
    {
      typedef Tp                                        value_type;
 
      template<typename Tl>
        struct deque_shell
        {
          typedef Tl                                    allocator_type;
          typedef std::deque<value_type, allocator_type>        type;
        };
 
      typedef allocator_policies<value_type, Thread>    allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, deque_shell>::type type;
    };
 
  template<typename Tp, bool Thread>
    struct strings
    {
      typedef Tp                                        value_type;
 
      template<typename Tl>
        struct string_shell
        {
          typedef Tl                                    allocator_type;
          typedef std::char_traits<value_type>          traits_type;
          typedef std::basic_string<value_type, traits_type, allocator_type>    type;
        };
 
      typedef allocator_policies<value_type, Thread>    allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, string_shell>::type type;
    };
 
  // A typelist of vector, list, deque, and string all instantiated
  // with each of the allocator policies.
  template<typename Tp, bool Thread>
    struct sequence_containers
    {
      typedef Tp                                        value_type;
 
      typedef typename vectors<value_type, Thread>::type vector_typelist;
      typedef typename lists<value_type, Thread>::type   list_typelist;
      typedef typename deques<value_type, Thread>::type  deque_typelist;
      typedef typename strings<value_type, Thread>::type string_typelist;
 
      typedef typename append<vector_typelist, list_typelist>::type a1;
      typedef typename append<deque_typelist, string_typelist>::type a2;
      typedef typename append<a1, a2>::type type;
    };
 
  // Typelists for map, set, unordered_set, unordered_map.
  template<typename Tp, bool Thread>
    struct maps
    {
      typedef Tp                                        value_type;
      typedef Tp                                        key_type;
      typedef std::pair<const key_type, value_type>     pair_type;
      typedef std::less<key_type>                       compare_function;
 
      template<typename Tl>
        struct container
        {
          typedef Tl                                    allocator_type;
          typedef std::map<key_type, value_type, compare_function, allocator_type>      type;
        };
 
      typedef allocator_policies<pair_type, Thread>     allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, container>::type type;
    };
 
  template<typename Tp, bool Thread>
    struct unordered_maps
    {
      typedef Tp                                        value_type;
      typedef Tp                                        key_type;
      typedef std::pair<const key_type, value_type>     pair_type;
      typedef std::tr1::hash<key_type>                  hash_function;
      typedef std::equal_to<key_type>                   equality_function;
 
      template<typename Tl>
        struct container
        {
          typedef Tl                                    allocator_type;
          typedef std::tr1::unordered_map<key_type, value_type, hash_function, equality_function, allocator_type>       type;
        };
 
      typedef allocator_policies<pair_type, Thread>     allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, container>::type type;
    };
 
  template<typename Tp, bool Thread>
    struct sets
    {
      typedef Tp                                        value_type;
      typedef Tp                                        key_type;
      typedef std::less<key_type>                       compare_function;
 
      template<typename Tl>
        struct container
        {
          typedef Tl                                    allocator_type;
          typedef std::set<key_type, compare_function, allocator_type>  type;
        };
 
      typedef allocator_policies<key_type, Thread>      allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, container>::type type;
    };
 
  template<typename Tp, bool Thread>
    struct unordered_sets
    {
      typedef Tp                                        value_type;
      typedef Tp                                        key_type;
      typedef std::tr1::hash<key_type>                  hash_function;
      typedef std::equal_to<key_type>                   equality_function;
 
      template<typename Tl>
        struct container
        {
          typedef Tl                                    allocator_type;
          typedef std::tr1::unordered_set<key_type, hash_function, equality_function, allocator_type>   type;
        };
 
      typedef allocator_policies<key_type, Thread>      allocator_types;
      typedef typename allocator_types::type            allocator_typelist;
      typedef typename transform<allocator_typelist, container>::type type;
    };
 
 
  // A typelist  of all associated  container types, with each  of the
  // allocator policies.
  template<typename Tp, bool Thread>
    struct associative_containers
    {
      typedef Tp                                        value_type;
 
      typedef typename maps<value_type, Thread>::type map_typelist;
      typedef typename sets<value_type, Thread>::type set_typelist;
      typedef typename unordered_maps<value_type, Thread>::type unordered_map_typelist;
      typedef typename unordered_sets<value_type, Thread>::type unordered_set_typelist;
 
      typedef typename append<map_typelist, unordered_map_typelist>::type a1;
      typedef typename append<set_typelist, unordered_set_typelist>::type a2;
      typedef typename append<a1, a2>::type type;
    };
 
  // A typelist of all integral types.
  struct integral_types
  {
    typedef bool                a1;
    typedef char                a2;
    typedef signed char         a3;
    typedef unsigned char       a4;
    typedef short               a5;
    typedef unsigned short      a6;
    typedef int                 a7;
    typedef unsigned int        a8;
    typedef long                a9;
    typedef unsigned long       a10;
    typedef long long           a11;
    typedef unsigned long long  a12;
    typedef wchar_t             a13;
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    typedef char16_t            a14;
    typedef char32_t            a15;
 
    typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,
                                           a10, a11, a12, a13, a14, a15)> type;
#else
    typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9,
                                           a10, a11, a12, a13)> type;
#endif
  };
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
  struct atomic_integrals_no_bool
  {
    typedef std::atomic_char            a2;
    typedef std::atomic_schar           a3;
    typedef std::atomic_uchar           a4;
    typedef std::atomic_short           a5;
    typedef std::atomic_ushort          a6;
    typedef std::atomic_int             a7;
    typedef std::atomic_uint            a8;
    typedef std::atomic_long            a9;
    typedef std::atomic_ulong           a10;
    typedef std::atomic_llong           a11;
    typedef std::atomic_ullong          a12;
    typedef std::atomic_wchar_t         a13;
    typedef std::atomic_char16_t        a14;
    typedef std::atomic_char32_t        a15;
 
    typedef node<_GLIBCXX_TYPELIST_CHAIN14(a2, a3, a4, a5, a6, a7, a8, a9,
                                           a10, a11, a12, a13, a14, a15)> type;
  };
 
  struct atomic_integrals
  {
    typedef std::atomic_bool            a1;
    typedef std::atomic_char            a2;
    typedef std::atomic_schar           a3;
    typedef std::atomic_uchar           a4;
    typedef std::atomic_short           a5;
    typedef std::atomic_ushort          a6;
    typedef std::atomic_int             a7;
    typedef std::atomic_uint            a8;
    typedef std::atomic_long            a9;
    typedef std::atomic_ulong           a10;
    typedef std::atomic_llong           a11;
    typedef std::atomic_ullong          a12;
    typedef std::atomic_wchar_t         a13;
    typedef std::atomic_char16_t        a14;
    typedef std::atomic_char32_t        a15;
 
    typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,
                                           a10, a11, a12, a13, a14, a15)> type;
  };
 
 
  template<typename Tp>
    struct atomics
    {
      typedef Tp                        value_type;
      typedef std::atomic<value_type>   type;
    };
 
  typedef transform<integral_types::type, atomics>::type atomics_tl;
#endif
 
 
  struct has_increment_operators
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            _Tp a;
            ++a; // prefix
            a++; // postfix
            a += a;
          }
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  struct has_decrement_operators
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            _Tp a;
            --a; // prefix
            a--; // postfix
            a -= a;
          }
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  template<typename _Tp>
    void
    bitwise_operators()
    {
      _Tp a = _Tp();
      _Tp b = _Tp();
      a | b;
      a & b;
      a ^ b;
      ~b;
    }
 
  template<typename _Tp>
    void
    bitwise_assignment_operators()
    {
      _Tp a = _Tp();
      _Tp b = _Tp();
      a |= b; // set
      a &= ~b; // clear
      a ^= b;
    }
 
  // 17.3.2.1.2 - Bitmask types [lib.bitmask.types]
  // bitmask_operators
  template<typename _BitmTp>
    void
    bitmask_operators()
    {
      bitwise_operators<_BitmTp>();
      bitwise_assignment_operators<_BitmTp>();
    }
 
  struct has_bitwise_operators
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            a |= b; // set
            a &= ~b; // clear
            a ^= b;
          }
          _Tp a;
          _Tp b;
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test standard layout
#ifdef __GXX_EXPERIMENTAL_CXX0X__
  struct has_trivial_cons_dtor
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            typedef std::has_trivial_default_constructor<_Tp> ctor_p;
            static_assert(ctor_p::value, "default constructor not trivial");
 
            typedef std::has_trivial_destructor<_Tp> dtor_p;
            static_assert(dtor_p::value, "destructor not trivial");
          }
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  struct standard_layout
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            typedef std::is_standard_layout<_Tp> standard_layout_p;
            static_assert(standard_layout_p::value, "not standard_layout");
          }
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
#endif
 
  // Generator to test base class
  struct has_required_base_class
  {
    template<typename _TBase, typename _TDerived>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            const _TDerived& obj = __a;
            const _TBase* base __attribute__((unused)) = &obj;
          }
 
          _TDerived __a;
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test assignment operator.
  struct assignable
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          { __v1 = __v2; }
 
          _Tp __v1;
          _Tp __v2;
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test default constructor.
  struct default_constructible
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          { _Tp __v; }
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test copy constructor.
  struct copy_constructible
  {
    template<typename _Tp>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          { _Tp __v2(__v1); }
 
          _Tp __v1;
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test direct initialization, single value constructor.
  struct single_value_constructible
  {
    template<typename _Ttype, typename _Tvalue>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          { _Ttype __v(__a); }
 
          _Tvalue __a;
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test direct list initialization
#ifdef __GXX_EXPERIMENTAL_CXX0X__
  struct direct_list_initializable
  {
    template<typename _Ttype, typename _Tvalue>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            _Ttype __v1 { }; // default ctor
            _Ttype __v2 { __a };  // single-argument ctor
          }
 
          _Tvalue __a;
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
#endif
 
  // Generator to test copy list initialization, aggregate initialization
  struct copy_list_initializable
  {
    template<typename _Ttype, typename _Tvalue>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          { _Ttype __v = {__a}; }
 
          _Tvalue __a;
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test integral conversion operator
  struct integral_convertable
  {
    template<typename _Ttype, typename _Tvalue>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            _Tvalue __v0(0);
            _Tvalue __v1(1);
            _Ttype __a(__v1);
            __v0 = __a;
 
            bool test __attribute__((unused)) = true;
            VERIFY( __v1 == __v0 );
          }
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
 
  // Generator to test integral assignment operator 
  struct integral_assignable
  {
    template<typename _Ttype, typename _Tvalue>
      void
      operator()()
      {
        struct _Concept
        {
          void __constraint()
          {
            _Tvalue __v0(0);
            _Tvalue __v1(1);
            _Ttype __a(__v0);
            __a = __v1;
            _Tvalue __vr = __a;
 
            bool test __attribute__((unused)) = true;
            VERIFY( __v1 == __vr );
          }
        };
 
        void (_Concept::*__x)() __attribute__((unused))
          = &_Concept::__constraint;
      }
  };
} // namespace __gnu_test
#endif

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [libstdc++-v3/] [testsuite/] [util/] [testsuite_common_types.h] - Blame information for rev 516

Line No.	Rev	Author	Line
1	424	jeremybenn	`// -- C++ --`
2			`// typelist for the C++ library testsuite.`
3			`//`
4			`// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.`
5			`//`
6			`// This file is part of the GNU ISO C++ Library. This library is free`
7			`// software; you can redistribute it and/or modify it under the`
8			`// terms of the GNU General Public License as published by the`
9			`// Free Software Foundation; either version 3, or (at your option)`
10			`// any later version.`
11			`//`
12			`// This library is distributed in the hope that it will be useful,`
13			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`// GNU General Public License for more details.`
16			`//`
17			`// You should have received a copy of the GNU General Public License along`
18			`// with this library; see the file COPYING3. If not see`
19			`// <http://www.gnu.org/licenses/>.`
20			`//`
21
22			`#ifndef _TESTSUITE_COMMON_TYPES_H`
23			`#define _TESTSUITE_COMMON_TYPES_H 1`
24
25			`#include <ext/typelist.h>`
26
27			`#include <ext/new_allocator.h>`
28			`#include <ext/malloc_allocator.h>`
29			`#include <ext/mt_allocator.h>`
30			`#include <ext/bitmap_allocator.h>`
31			`#include <ext/pool_allocator.h>`
32
33			`#include <algorithm>`
34
35			`#include <vector>`
36			`#include <list>`
37			`#include <deque>`
38			`#include <string>`
39
40			`#include <map>`
41			`#include <set>`
42			`#include <tr1/functional>`
43			`#include <tr1/unordered_map>`
44			`#include <tr1/unordered_set>`
45
46			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
47			`#include <atomic>`
48			`#include <type_traits>`
49			`#endif`
50
51			`namespace __gnu_test`
52			`{`
53			`using __gnu_cxx::typelist::node;`
54			`using __gnu_cxx::typelist::transform;`
55			`using __gnu_cxx::typelist::append;`
56
57			`// All the allocators to test.`
58			`template<typename Tp, bool Thread>`
59			`struct allocator_policies`
60			`{`
61			`typedef Tp value_type;`
62			`typedef __gnu_cxx::new_allocator<Tp> a1;`
63			`typedef __gnu_cxx::malloc_allocator<Tp> a2;`
64			`typedef __gnu_cxx::__common_pool_policy<__gnu_cxx::__pool, Thread> pool_policy;`
65			`typedef __gnu_cxx::__mt_alloc<Tp, pool_policy> a3;`
66			`typedef __gnu_cxx::bitmap_allocator<Tp> a4;`
67			`typedef __gnu_cxx::__pool_alloc<Tp> a5;`
68			`typedef node<_GLIBCXX_TYPELIST_CHAIN5(a1, a2, a3, a4, a5)> type;`
69			`};`
70
71			`// Typelists for vector, string, list, deque.`
72			`// XXX should just use template templates`
73			`template<typename Tp, bool Thread>`
74			`struct vectors`
75			`{`
76			`typedef Tp value_type;`
77
78			`template<typename Tl>`
79			`struct vector_shell`
80			`{`
81			`typedef Tl allocator_type;`
82			`typedef std::vector<value_type, allocator_type> type;`
83			`};`
84
85			`typedef allocator_policies<value_type, Thread> allocator_types;`
86			`typedef typename allocator_types::type allocator_typelist;`
87			`typedef typename transform<allocator_typelist, vector_shell>::type type;`
88			`};`
89
90			`template<typename Tp, bool Thread>`
91			`struct lists`
92			`{`
93			`typedef Tp value_type;`
94
95			`template<typename Tl>`
96			`struct list_shell`
97			`{`
98			`typedef Tl allocator_type;`
99			`typedef std::list<value_type, allocator_type> type;`
100			`};`
101
102			`typedef allocator_policies<value_type, Thread> allocator_types;`
103			`typedef typename allocator_types::type allocator_typelist;`
104			`typedef typename transform<allocator_typelist, list_shell>::type type;`
105			`};`
106
107			`template<typename Tp, bool Thread>`
108			`struct deques`
109			`{`
110			`typedef Tp value_type;`
111
112			`template<typename Tl>`
113			`struct deque_shell`
114			`{`
115			`typedef Tl allocator_type;`
116			`typedef std::deque<value_type, allocator_type> type;`
117			`};`
118
119			`typedef allocator_policies<value_type, Thread> allocator_types;`
120			`typedef typename allocator_types::type allocator_typelist;`
121			`typedef typename transform<allocator_typelist, deque_shell>::type type;`
122			`};`
123
124			`template<typename Tp, bool Thread>`
125			`struct strings`
126			`{`
127			`typedef Tp value_type;`
128
129			`template<typename Tl>`
130			`struct string_shell`
131			`{`
132			`typedef Tl allocator_type;`
133			`typedef std::char_traits<value_type> traits_type;`
134			`typedef std::basic_string<value_type, traits_type, allocator_type> type;`
135			`};`
136
137			`typedef allocator_policies<value_type, Thread> allocator_types;`
138			`typedef typename allocator_types::type allocator_typelist;`
139			`typedef typename transform<allocator_typelist, string_shell>::type type;`
140			`};`
141
142			`// A typelist of vector, list, deque, and string all instantiated`
143			`// with each of the allocator policies.`
144			`template<typename Tp, bool Thread>`
145			`struct sequence_containers`
146			`{`
147			`typedef Tp value_type;`
148
149			`typedef typename vectors<value_type, Thread>::type vector_typelist;`
150			`typedef typename lists<value_type, Thread>::type list_typelist;`
151			`typedef typename deques<value_type, Thread>::type deque_typelist;`
152			`typedef typename strings<value_type, Thread>::type string_typelist;`
153
154			`typedef typename append<vector_typelist, list_typelist>::type a1;`
155			`typedef typename append<deque_typelist, string_typelist>::type a2;`
156			`typedef typename append<a1, a2>::type type;`
157			`};`
158
159			`// Typelists for map, set, unordered_set, unordered_map.`
160			`template<typename Tp, bool Thread>`
161			`struct maps`
162			`{`
163			`typedef Tp value_type;`
164			`typedef Tp key_type;`
165			`typedef std::pair<const key_type, value_type> pair_type;`
166			`typedef std::less<key_type> compare_function;`
167
168			`template<typename Tl>`
169			`struct container`
170			`{`
171			`typedef Tl allocator_type;`
172			`typedef std::map<key_type, value_type, compare_function, allocator_type> type;`
173			`};`
174
175			`typedef allocator_policies<pair_type, Thread> allocator_types;`
176			`typedef typename allocator_types::type allocator_typelist;`
177			`typedef typename transform<allocator_typelist, container>::type type;`
178			`};`
179
180			`template<typename Tp, bool Thread>`
181			`struct unordered_maps`
182			`{`
183			`typedef Tp value_type;`
184			`typedef Tp key_type;`
185			`typedef std::pair<const key_type, value_type> pair_type;`
186			`typedef std::tr1::hash<key_type> hash_function;`
187			`typedef std::equal_to<key_type> equality_function;`
188
189			`template<typename Tl>`
190			`struct container`
191			`{`
192			`typedef Tl allocator_type;`
193			`typedef std::tr1::unordered_map<key_type, value_type, hash_function, equality_function, allocator_type> type;`
194			`};`
195
196			`typedef allocator_policies<pair_type, Thread> allocator_types;`
197			`typedef typename allocator_types::type allocator_typelist;`
198			`typedef typename transform<allocator_typelist, container>::type type;`
199			`};`
200
201			`template<typename Tp, bool Thread>`
202			`struct sets`
203			`{`
204			`typedef Tp value_type;`
205			`typedef Tp key_type;`
206			`typedef std::less<key_type> compare_function;`
207
208			`template<typename Tl>`
209			`struct container`
210			`{`
211			`typedef Tl allocator_type;`
212			`typedef std::set<key_type, compare_function, allocator_type> type;`
213			`};`
214
215			`typedef allocator_policies<key_type, Thread> allocator_types;`
216			`typedef typename allocator_types::type allocator_typelist;`
217			`typedef typename transform<allocator_typelist, container>::type type;`
218			`};`
219
220			`template<typename Tp, bool Thread>`
221			`struct unordered_sets`
222			`{`
223			`typedef Tp value_type;`
224			`typedef Tp key_type;`
225			`typedef std::tr1::hash<key_type> hash_function;`
226			`typedef std::equal_to<key_type> equality_function;`
227
228			`template<typename Tl>`
229			`struct container`
230			`{`
231			`typedef Tl allocator_type;`
232			`typedef std::tr1::unordered_set<key_type, hash_function, equality_function, allocator_type> type;`
233			`};`
234
235			`typedef allocator_policies<key_type, Thread> allocator_types;`
236			`typedef typename allocator_types::type allocator_typelist;`
237			`typedef typename transform<allocator_typelist, container>::type type;`
238			`};`
239
240
241			`// A typelist of all associated container types, with each of the`
242			`// allocator policies.`
243			`template<typename Tp, bool Thread>`
244			`struct associative_containers`
245			`{`
246			`typedef Tp value_type;`
247
248			`typedef typename maps<value_type, Thread>::type map_typelist;`
249			`typedef typename sets<value_type, Thread>::type set_typelist;`
250			`typedef typename unordered_maps<value_type, Thread>::type unordered_map_typelist;`
251			`typedef typename unordered_sets<value_type, Thread>::type unordered_set_typelist;`
252
253			`typedef typename append<map_typelist, unordered_map_typelist>::type a1;`
254			`typedef typename append<set_typelist, unordered_set_typelist>::type a2;`
255			`typedef typename append<a1, a2>::type type;`
256			`};`
257
258			`// A typelist of all integral types.`
259			`struct integral_types`
260			`{`
261			`typedef bool a1;`
262			`typedef char a2;`
263			`typedef signed char a3;`
264			`typedef unsigned char a4;`
265			`typedef short a5;`
266			`typedef unsigned short a6;`
267			`typedef int a7;`
268			`typedef unsigned int a8;`
269			`typedef long a9;`
270			`typedef unsigned long a10;`
271			`typedef long long a11;`
272			`typedef unsigned long long a12;`
273			`typedef wchar_t a13;`
274			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
275			`typedef char16_t a14;`
276			`typedef char32_t a15;`
277
278			`typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,`
279			`a10, a11, a12, a13, a14, a15)> type;`
280			`#else`
281			`typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9,`
282			`a10, a11, a12, a13)> type;`
283			`#endif`
284			`};`
285
286			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
287			`struct atomic_integrals_no_bool`
288			`{`
289			`typedef std::atomic_char a2;`
290			`typedef std::atomic_schar a3;`
291			`typedef std::atomic_uchar a4;`
292			`typedef std::atomic_short a5;`
293			`typedef std::atomic_ushort a6;`
294			`typedef std::atomic_int a7;`
295			`typedef std::atomic_uint a8;`
296			`typedef std::atomic_long a9;`
297			`typedef std::atomic_ulong a10;`
298			`typedef std::atomic_llong a11;`
299			`typedef std::atomic_ullong a12;`
300			`typedef std::atomic_wchar_t a13;`
301			`typedef std::atomic_char16_t a14;`
302			`typedef std::atomic_char32_t a15;`
303
304			`typedef node<_GLIBCXX_TYPELIST_CHAIN14(a2, a3, a4, a5, a6, a7, a8, a9,`
305			`a10, a11, a12, a13, a14, a15)> type;`
306			`};`
307
308			`struct atomic_integrals`
309			`{`
310			`typedef std::atomic_bool a1;`
311			`typedef std::atomic_char a2;`
312			`typedef std::atomic_schar a3;`
313			`typedef std::atomic_uchar a4;`
314			`typedef std::atomic_short a5;`
315			`typedef std::atomic_ushort a6;`
316			`typedef std::atomic_int a7;`
317			`typedef std::atomic_uint a8;`
318			`typedef std::atomic_long a9;`
319			`typedef std::atomic_ulong a10;`
320			`typedef std::atomic_llong a11;`
321			`typedef std::atomic_ullong a12;`
322			`typedef std::atomic_wchar_t a13;`
323			`typedef std::atomic_char16_t a14;`
324			`typedef std::atomic_char32_t a15;`
325
326			`typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9,`
327			`a10, a11, a12, a13, a14, a15)> type;`
328			`};`
329
330
331			`template<typename Tp>`
332			`struct atomics`
333			`{`
334			`typedef Tp value_type;`
335			`typedef std::atomic<value_type> type;`
336			`};`
337
338			`typedef transform<integral_types::type, atomics>::type atomics_tl;`
339			`#endif`
340
341
342			`struct has_increment_operators`
343			`{`
344			`template<typename _Tp>`
345			`void`
346			`operator()()`
347			`{`
348			`struct _Concept`
349			`{`
350			`void __constraint()`
351			`{`
352			`_Tp a;`
353			`++a; // prefix`
354			`a++; // postfix`
355			`a += a;`
356			`}`
357			`};`
358
359			`void (_Concept::*__x)() __attribute__((unused))`
360			`= &_Concept::__constraint;`
361			`}`
362			`};`
363
364			`struct has_decrement_operators`
365			`{`
366			`template<typename _Tp>`
367			`void`
368			`operator()()`
369			`{`
370			`struct _Concept`
371			`{`
372			`void __constraint()`
373			`{`
374			`_Tp a;`
375			`--a; // prefix`
376			`a--; // postfix`
377			`a -= a;`
378			`}`
379			`};`
380
381			`void (_Concept::*__x)() __attribute__((unused))`
382			`= &_Concept::__constraint;`
383			`}`
384			`};`
385
386			`template<typename _Tp>`
387			`void`
388			`bitwise_operators()`
389			`{`
390			`_Tp a = _Tp();`
391			`_Tp b = _Tp();`
392			`a \| b;`
393			`a & b;`
394			`a ^ b;`
395			`~b;`
396			`}`
397
398			`template<typename _Tp>`
399			`void`
400			`bitwise_assignment_operators()`
401			`{`
402			`_Tp a = _Tp();`
403			`_Tp b = _Tp();`
404			`a \|= b; // set`
405			`a &= ~b; // clear`
406			`a ^= b;`
407			`}`
408
409			`// 17.3.2.1.2 - Bitmask types [lib.bitmask.types]`
410			`// bitmask_operators`
411			`template<typename _BitmTp>`
412			`void`
413			`bitmask_operators()`
414			`{`
415			`bitwise_operators<_BitmTp>();`
416			`bitwise_assignment_operators<_BitmTp>();`
417			`}`
418
419			`struct has_bitwise_operators`
420			`{`
421			`template<typename _Tp>`
422			`void`
423			`operator()()`
424			`{`
425			`struct _Concept`
426			`{`
427			`void __constraint()`
428			`{`
429			`a \|= b; // set`
430			`a &= ~b; // clear`
431			`a ^= b;`
432			`}`
433			`_Tp a;`
434			`_Tp b;`
435			`};`
436
437			`void (_Concept::*__x)() __attribute__((unused))`
438			`= &_Concept::__constraint;`
439			`}`
440			`};`
441
442			`// Generator to test standard layout`
443			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
444			`struct has_trivial_cons_dtor`
445			`{`
446			`template<typename _Tp>`
447			`void`
448			`operator()()`
449			`{`
450			`struct _Concept`
451			`{`
452			`void __constraint()`
453			`{`
454			`typedef std::has_trivial_default_constructor<_Tp> ctor_p;`
455			`static_assert(ctor_p::value, "default constructor not trivial");`
456
457			`typedef std::has_trivial_destructor<_Tp> dtor_p;`
458			`static_assert(dtor_p::value, "destructor not trivial");`
459			`}`
460			`};`
461
462			`void (_Concept::*__x)() __attribute__((unused))`
463			`= &_Concept::__constraint;`
464			`}`
465			`};`
466
467			`struct standard_layout`
468			`{`
469			`template<typename _Tp>`
470			`void`
471			`operator()()`
472			`{`
473			`struct _Concept`
474			`{`
475			`void __constraint()`
476			`{`
477			`typedef std::is_standard_layout<_Tp> standard_layout_p;`
478			`static_assert(standard_layout_p::value, "not standard_layout");`
479			`}`
480			`};`
481
482			`void (_Concept::*__x)() __attribute__((unused))`
483			`= &_Concept::__constraint;`
484			`}`
485			`};`
486			`#endif`
487
488			`// Generator to test base class`
489			`struct has_required_base_class`
490			`{`
491			`template<typename _TBase, typename _TDerived>`
492			`void`
493			`operator()()`
494			`{`
495			`struct _Concept`
496			`{`
497			`void __constraint()`
498			`{`
499			`const _TDerived& obj = __a;`
500			`const _TBase* base __attribute__((unused)) = &obj;`
501			`}`
502
503			`_TDerived __a;`
504			`};`
505
506			`void (_Concept::*__x)() __attribute__((unused))`
507			`= &_Concept::__constraint;`
508			`}`
509			`};`
510
511			`// Generator to test assignment operator.`
512			`struct assignable`
513			`{`
514			`template<typename _Tp>`
515			`void`
516			`operator()()`
517			`{`
518			`struct _Concept`
519			`{`
520			`void __constraint()`
521			`{ __v1 = __v2; }`
522
523			`_Tp __v1;`
524			`_Tp __v2;`
525			`};`
526
527			`void (_Concept::*__x)() __attribute__((unused))`
528			`= &_Concept::__constraint;`
529			`}`
530			`};`
531
532			`// Generator to test default constructor.`
533			`struct default_constructible`
534			`{`
535			`template<typename _Tp>`
536			`void`
537			`operator()()`
538			`{`
539			`struct _Concept`
540			`{`
541			`void __constraint()`
542			`{ _Tp __v; }`
543			`};`
544
545			`void (_Concept::*__x)() __attribute__((unused))`
546			`= &_Concept::__constraint;`
547			`}`
548			`};`
549
550			`// Generator to test copy constructor.`
551			`struct copy_constructible`
552			`{`
553			`template<typename _Tp>`
554			`void`
555			`operator()()`
556			`{`
557			`struct _Concept`
558			`{`
559			`void __constraint()`
560			`{ _Tp __v2(__v1); }`
561
562			`_Tp __v1;`
563			`};`
564
565			`void (_Concept::*__x)() __attribute__((unused))`
566			`= &_Concept::__constraint;`
567			`}`
568			`};`
569
570			`// Generator to test direct initialization, single value constructor.`
571			`struct single_value_constructible`
572			`{`
573			`template<typename _Ttype, typename _Tvalue>`
574			`void`
575			`operator()()`
576			`{`
577			`struct _Concept`
578			`{`
579			`void __constraint()`
580			`{ _Ttype __v(__a); }`
581
582			`_Tvalue __a;`
583			`};`
584
585			`void (_Concept::*__x)() __attribute__((unused))`
586			`= &_Concept::__constraint;`
587			`}`
588			`};`
589
590			`// Generator to test direct list initialization`
591			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
592			`struct direct_list_initializable`
593			`{`
594			`template<typename _Ttype, typename _Tvalue>`
595			`void`
596			`operator()()`
597			`{`
598			`struct _Concept`
599			`{`
600			`void __constraint()`
601			`{`
602			`_Ttype __v1 { }; // default ctor`
603			`_Ttype __v2 { __a }; // single-argument ctor`
604			`}`
605
606			`_Tvalue __a;`
607			`};`
608
609			`void (_Concept::*__x)() __attribute__((unused))`
610			`= &_Concept::__constraint;`
611			`}`
612			`};`
613			`#endif`
614
615			`// Generator to test copy list initialization, aggregate initialization`
616			`struct copy_list_initializable`
617			`{`
618			`template<typename _Ttype, typename _Tvalue>`
619			`void`
620			`operator()()`
621			`{`
622			`struct _Concept`
623			`{`
624			`void __constraint()`
625			`{ _Ttype __v = {__a}; }`
626
627			`_Tvalue __a;`
628			`};`
629
630			`void (_Concept::*__x)() __attribute__((unused))`
631			`= &_Concept::__constraint;`
632			`}`
633			`};`
634
635			`// Generator to test integral conversion operator`
636			`struct integral_convertable`
637			`{`
638			`template<typename _Ttype, typename _Tvalue>`
639			`void`
640			`operator()()`
641			`{`
642			`struct _Concept`
643			`{`
644			`void __constraint()`
645			`{`
646			`_Tvalue __v0(0);`
647			`_Tvalue __v1(1);`
648			`_Ttype __a(__v1);`
649			`__v0 = __a;`
650
651			`bool test __attribute__((unused)) = true;`
652			`VERIFY( __v1 == __v0 );`
653			`}`
654			`};`
655
656			`void (_Concept::*__x)() __attribute__((unused))`
657			`= &_Concept::__constraint;`
658			`}`
659			`};`
660
661			`// Generator to test integral assignment operator`
662			`struct integral_assignable`
663			`{`
664			`template<typename _Ttype, typename _Tvalue>`
665			`void`
666			`operator()()`
667			`{`
668			`struct _Concept`
669			`{`
670			`void __constraint()`
671			`{`
672			`_Tvalue __v0(0);`
673			`_Tvalue __v1(1);`
674			`_Ttype __a(__v0);`
675			`__a = __v1;`
676			`_Tvalue __vr = __a;`
677
678			`bool test __attribute__((unused)) = true;`
679			`VERIFY( __v1 == __vr );`
680			`}`
681			`};`
682
683			`void (_Concept::*__x)() __attribute__((unused))`
684			`= &_Concept::__constraint;`
685			`}`
686			`};`
687			`} // namespace __gnu_test`
688			`#endif`